/**
 * 研发项目模型
 * 优化版 - 使用小驼峰命名和规范的数据结构
 */
const BaseModel = require('./base_model.js');

// 研发项目集合名
const COLLECTION = 'plm_research_project';

// 研发项目状态历史集合名
const COLLECTION_HISTORY = 'plm_research_project_history';

// 研发项目状态定义
const STATUS = {
    DRAFT: 0,         // 草稿
    APPROVAL: 1,      // 审批中
    ACTIVE: 2,        // 执行中
    COMPLETED: 3,     // 已完成
    REJECTED: 4,      // 已拒绝
    CANCELED: 5,      // 已取消
    PAUSED: 6         // 已暂停
};

// 研发项目子状态定义
const SUB_STATUS = {
    // 审批子状态
    DIRECTOR: 'director',     // 董事长审批
    MANAGER: 'manager',       // 经理审批
    LEADER: 'leader',         // 组长审批
    APPROVE_COMPLETED: 'approved', // 审批通过
    
    // 执行子状态
    PLANNING: 'planning',      // 规划阶段
    DESIGN: 'design',          // 设计阶段
    DEVELOPMENT: 'development', // 开发阶段
    TESTING: 'testing',        // 测试阶段
    VALIDATION: 'validation'   // 验证阶段
};

// 项目活动状态定义
const ACTIVE_STATUS = {
    // 设计阶段活动
    SCHEMATIC: 'schematic',    // 原理图设计 
    PCB: 'pcb',                // PCB设计
    BOM: 'bom',                // BOM清单编制
    
    // 开发阶段活动
    FIRMWARE: 'firmware',      // 固件开发
    SOFTWARE: 'software',      // 软件开发
    TUNING: 'tuning',          // 调试
    
    // 测试阶段活动
    FUNCTION_TEST: 'functionTest',  // 功能测试
    SAFETY_TEST: 'safetyTest',      // 安全测试
    EMC_TEST: 'emcTest',            // EMC测试
    ENDURANCE_TEST: 'enduranceTest' // 耐久测试
};

// 项目优先级定义
const PRIORITY = {
    URGENT: 'urgent',     // 紧急
    HIGH: 'high',         // 高
    NORMAL: 'normal',     // 中
    LOW: 'low'            // 低
};

// 项目类别定义
const CATEGORY = {
    RESEARCH: '研发',     // 研发类 
    CUSTOMIZE: '定制',    // 定制类
    MASS: '量产',         // 量产类
    PLATFORM: '平台',     // 平台类
    OTHER: '其他'         // 其他类型
};

// 项目类型定义
const PROJECT_TYPE = {
    MOTOR_CONTROL: 1,    // 电机控制
    POWER_SUPPLY: 2,     // 电源类
    SENSOR: 3,           // 传感器类
    OTHER: 4             // 其他类型
};

// 项目类型名称
const PROJECT_TYPE_NAME = {
    1: '电机控制类',
    2: '电源类',
    3: '传感器类', 
    4: '其他类型'
};

// 应用类型到项目类型的映射
const APP_TYPE_MAPPING = {
    '磁编': PROJECT_TYPE.MOTOR_CONTROL,
    '霍尔': PROJECT_TYPE.MOTOR_CONTROL,
    '风机': PROJECT_TYPE.MOTOR_CONTROL,
    '水泵': PROJECT_TYPE.MOTOR_CONTROL,
    '电源': PROJECT_TYPE.POWER_SUPPLY,
    '传感器': PROJECT_TYPE.SENSOR,
    '其他': PROJECT_TYPE.OTHER
};

// 工作流类型
const FLOW_TYPE = {
    NORMAL: 1,     // 正常流转
    REJECT: 2,     // 拒绝
    REVERSE: 3,    // 回退
    BYPASS: 4      // 跳过
};

/**
 * 研发项目模型类
 */
class ResearchProjectModel extends BaseModel {
    
    /**
     * 构造函数
     * @param {Object} opt 配置对象
     */
    constructor(opt) {
        super(opt);
        
        this._collection = COLLECTION;
        this._historyCollection = COLLECTION_HISTORY;
    }
    
    /**
     * 插入研发项目
     * @param {Object} data 项目数据
     * @returns {Promise<string>} 插入的项目ID
     */
    async insert(data) {
        data.createTime = data.createTime || Math.floor(Date.now() / 1000);
        data.updateTime = data.updateTime || data.createTime;
        data.stateTime = data.stateTime || data.createTime;
        
        // 确保状态相关字段存在
        data.level1 = data.level1 || STATUS.DRAFT;
        data.level2 = data.level2 || '';
        data.level3 = data.level3 || '';
        data.level4 = data.level4 || '';
        
        // 自动生成状态描述
        data.statusDesc = data.statusDesc || this.getStatusDesc(data);
        
        return await super.insert(data);
    }
    
    /**
     * 更新研发项目
     * @param {string} id 项目ID
     * @param {Object} data 更新数据
     * @returns {Promise<boolean>} 更新结果
     */
    async update(id, data) {
        // 更新时间
        data.updateTime = Math.floor(Date.now() / 1000);
        
        // 状态变更时更新状态时间
        if (data.level1 !== undefined || data.level2 !== undefined || 
            data.level3 !== undefined || data.level4 !== undefined) {
            data.stateTime = data.updateTime;
        }
        
        return await super.update(id, data);
    }
    
    /**
     * 更新项目状态
     * @param {string} id 项目ID
     * @param {number} level1 状态一级
     * @param {string} level2 状态二级
     * @param {string} level3 状态三级
     * @param {string} level4 状态四级
     * @returns {Promise<boolean>} 更新结果
     */
    async updateStatus(id, level1, level2 = '', level3 = '', level4 = '') {
        const now = Math.floor(Date.now() / 1000);
        
        const data = {
            level1,
            level2,
            level3,
            level4,
            stateTime: now,
            updateTime: now
        };
        
        // 自动生成状态描述
        data.statusDesc = this.getStatusDesc(data);
        
        return await super.update(id, data);
    }
    
    /**
     * 获取项目状态描述
     * @param {Object} data 项目数据
     * @returns {string} 状态描述
     */
    getStatusDesc(data) {
        // 获取主状态描述
        let mainStatus = '未知状态';
        switch (data.level1) {
            case STATUS.DRAFT:
                mainStatus = '草稿';
                break;
            case STATUS.APPROVAL:
                mainStatus = '项目审核';
                break;
            case STATUS.ACTIVE:
                mainStatus = '项目执行';
                break;
            case STATUS.COMPLETED:
                mainStatus = '已完成';
                break;
            case STATUS.REJECTED:
                mainStatus = '已拒绝';
                break;
            case STATUS.CANCELED:
                mainStatus = '已取消';
                break;
            case STATUS.PAUSED:
                mainStatus = '已暂停';
                break;
        }
        
        // 获取子状态描述
        let subStatus = '';
        
        // 审批状态子描述
        if (data.level1 === STATUS.APPROVAL) {
            switch (data.level2) {
                case SUB_STATUS.DIRECTOR:
                    subStatus = '董事长';
                    break;
                case SUB_STATUS.MANAGER:
                    subStatus = '经理';
                    break;
                case SUB_STATUS.LEADER:
                    subStatus = '组长';
                    break;
                case SUB_STATUS.APPROVE_COMPLETED:
                    subStatus = '审批完成';
                    break;
            }
        }
        
        // 执行状态子描述
        if (data.level1 === STATUS.ACTIVE) {
            switch (data.level2) {
                case SUB_STATUS.PLANNING:
                    subStatus = '规划阶段';
                    break;
                case SUB_STATUS.DESIGN:
                    subStatus = '设计阶段';
                    break;
                case SUB_STATUS.DEVELOPMENT:
                    subStatus = '开发阶段';
                    break;
                case SUB_STATUS.TESTING:
                    subStatus = '测试阶段';
                    break;
                case SUB_STATUS.VALIDATION:
                    subStatus = '验证阶段';
                    break;
            }
            
            // 第三级状态描述
            if (data.level3) {
                let activityDesc = '';
                switch (data.level3) {
                    case ACTIVE_STATUS.SCHEMATIC:
                        activityDesc = '原理图设计';
                        break;
                    case ACTIVE_STATUS.PCB:
                        activityDesc = 'PCB设计';
                        break;
                    case ACTIVE_STATUS.BOM:
                        activityDesc = 'BOM清单';
                        break;
                    case ACTIVE_STATUS.FIRMWARE:
                        activityDesc = '固件开发';
                        break;
                    case ACTIVE_STATUS.SOFTWARE:
                        activityDesc = '软件开发';
                        break;
                    case ACTIVE_STATUS.TUNING:
                        activityDesc = '调试';
                        break;
                    case ACTIVE_STATUS.FUNCTION_TEST:
                        activityDesc = '功能测试';
                        break;
                    case ACTIVE_STATUS.SAFETY_TEST:
                        activityDesc = '安全测试';
                        break;
                    case ACTIVE_STATUS.EMC_TEST:
                        activityDesc = 'EMC测试';
                        break;
                    case ACTIVE_STATUS.ENDURANCE_TEST:
                        activityDesc = '耐久测试';
                        break;
                }
                
                if (activityDesc) {
                    subStatus = subStatus + ' > ' + activityDesc;
                }
            }
        }
        
        return subStatus ? `${mainStatus} > ${subStatus}` : mainStatus;
    }
    
    /**
     * 插入状态历史记录
     * @param {Object} data 状态历史数据
     * @returns {Promise<string>} 插入的历史记录ID
     */
    async insertStateHistory(data) {
        // 添加时间戳
        data.createTime = data.createTime || Math.floor(Date.now() / 1000);
        
        const db = this.db.collection(this._historyCollection);
        const result = await db.add({ data });
        return result._id;
    }
    
    /**
     * 获取项目状态历史
     * @param {string} projectId 项目ID
     * @param {Object} options 查询选项
     * @returns {Promise<Array>} 状态历史列表
     */
    async getStateHistory(projectId, options = {}) {
        const db = this.db.collection(this._historyCollection);
        
        // 构建查询条件
        const condition = { projectId };
        
        // 查询记录总数
        const countResult = await db.where(condition).count();
        const total = countResult.total;
        
        // 没有记录直接返回
        if (total === 0) {
            return { total: 0, list: [] };
        }
        
        // 构建查询
        const page = options.page || 1;
        const size = options.size || 10;
        const skip = (page - 1) * size;
        const orderBy = options.orderBy || 'createTime';
        const sort = options.sort === 'asc' ? 'asc' : 'desc';
        
        let query = db.where(condition);
        
        // 添加排序
        if (sort === 'asc') {
            query = query.orderBy(orderBy, 'asc');
        } else {
            query = query.orderBy(orderBy, 'desc');
        }
        
        // 分页查询
        query = query.skip(skip).limit(size);
        
        // 执行查询
        const result = await query.get();
        
        return {
            total,
            list: result.data
        };
    }
    
    /**
     * 获取DB结构
     */
    static getDBStructure() {
        return {
            _pid: 'string|true',      // 项目ID (系统保留，不修改)
            
            // 基础标识信息
            model: 'string|true',     // 型号
            projectType: 'string|true|default=霍尔', // 项目类型
            customerName: 'string|true', // 客户名称
            startDate: 'int|true',    // 开始日期
            deadline: 'int|true',     // 截止日期
            priority: 'string|true|default=normal', // 优先级: low, normal, high, urgent
            description: 'string|false', // 项目描述
            
            // 样机信息
            hasSample: 'string|true|default=无', // 有无样机
            sampleCount: 'string|false', // 样品需求量
            sampleImages: 'array|false|default=[]', // 样机图片
            
            // 基本参数
            workTemp: 'string|false',       // 工作环境温度
            certification: 'string|false',  // 认证要求
            lowPower: 'string|false',       // 低功耗要求
            startupTime: 'string|false',    // 启动时间要求
            conformalCoating: 'string|false|default=无', // 三防漆要求
            
            // 电机基本参数
            ratedVoltage: 'string|false',   // 额定电压
            maxPower: 'string|false',       // 最大功率
            maxSpeed: 'string|false',       // 最高转速
            polePairs: 'string|false',      // 极对数
            hasHall: 'string|false|default=无',  // HALL/磁编
            hasFG: 'string|false|default=无',    // FG信号
            hasBrake: 'string|false|default=无',  // 刹车功能
            
            // 控制参数
            controlMode: 'string|false|default=恒功率',  // 控制模式
            controlAlgorithm: 'string|false|default=FOC', // 控制算法
            rotation: 'string|false|default=无',       // 正反转方式
            controlInterface: 'string|false|default=按键控制', // 控制方式
            
            // 保护参数
            stallProtection: 'string|false|default=无', // 堵转保护
            overvoltageProtection: 'string|false|default=无', // 过压保护
            undervoltageProtection: 'string|false|default=无', // 欠压保护
            temperatureProtection: 'string|false|default=无', // 温度保护
            overcurrentProtection: 'string|false|default=无', // 过流保护
            currentLimitProtection: 'string|false|default=无', // 限流保护
            blockageProtection: 'string|false|default=无', // 堵孔/空转保护
            phaseProtection: 'string|false|default=无',    // 缺相保护
            
            // PWM控制参数
            pwmStartDuty: 'string|false',  // 开机点占空比
            pwmStopDuty: 'string|false',   // 关机点占空比
            pwmDutyRange: 'string|false',  // 有效占空比
            pwmFreqRange: 'string|false',  // 频率范围
            
            // VSP控制参数
            vspStartVoltage: 'string|false', // 开机点电压
            vspStopVoltage: 'string|false',  // 关机点电压
            vspVoltageRange: 'string|false', // 有效电压范围
            
            // 项目管理和状态信息
            level1: 'int|true',     // 一级状态
            level2: 'string|false',           // 二级状态
            level3: 'string|false',           // 三级状态
            level4: 'string|false',           // 四级状态
            statusDesc: 'string|true',        // 状态描述
            
            // 时间信息
            createTime: 'int|true',      // 创建时间
            updateTime: 'int|true',      // 更新时间
            stateTime: 'int|true',       // 状态更新时间
            
            // 人员信息
            applicantId: 'string|true',       // 申请人ID
            applicantName: 'string|true',     // 申请人姓名
            projectLeadId: 'string|false', // 项目负责人ID
            projectLead: 'string|false', // 项目负责人姓名
            teamMembers: 'array|true|default=[]', // 团队成员列表
        };
    }
}

module.exports = ResearchProjectModel; 